package basic

import (
	"fmt"
	"sort"
)

func Slice() {
	//由于数组长度是固定的，所以数组使用有很多局限性
	//切片是同一种数据类型元素的可变长度的序列
	//引用类型 底层是struct
	//定义 var 变量名 []T
	var a []int
	var b []string
	fmt.Print(a, b)

	//长度len() 容量cap()
	//从数组中取切片 low<=索引值<height
	c := []int{1, 2, 3, 4, 5}
	d := c[1:2]
	fmt.Print(c, d, cap(d), cap(c))

	//make()函数构造切片
	e := make([]int, 2)
	fmt.Print(e)

	//检查切片是否为空
	var f []int
	if len(f) == 0 {
		fmt.Print("切片为空")
	}

	//引用类型
	g := []int{1, 2}
	h := g
	h[0] = 2
	fmt.Print(h, g)

	//append()
	//注意：通过var声明的零值切片可以在append()函数直接使用，无需初始化。
	//append()函数将元素追加到切片的最后并返回该切片。
	//切片numSlice的容量按照1，2，4，8，16这样的规则自动进行扩容，每次扩容后都是扩容前的2倍。
	//切片扩容策略
	//首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
	//否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
	//否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
	//如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。
	var i []int
	tmp := []int{3, 4, 5}
	i = append(i, tmp...)
	fmt.Print(i)

	//copy()
	j := []int{2}
	k := make([]int, 1)
	copy(k, j)
	k = append(k, 1)
	fmt.Print(j, k)

	//切片删除元素
	aa := []int{1, 2, 3, 4, 5}
	aa = append(aa[:1], aa[2:]...)
	fmt.Print(aa)

	slice()

	sortSlice()
}

func slice() {
	var a = make([]string, 5, 10)
	for i := 0; i < 10; i++ {
		a = append(a, fmt.Sprintf("%v", i))
	}
	fmt.Println(a)
}

func sortSlice() {
	var a = []int{3, 7, 8, 9, 1}
	fmt.Print(a[:])
	sort.Ints(a[:])
	fmt.Print(a)
}
